//Programa que separa os três canais (RGB) e exibi uma imagem de cada canal
#include <opencv2/opencv.hpp>
using namespace cv;

int main(int argc, char**argv)
{
  Mat img;
  Mat ch[3];

  img = imread(argv[1],CV_LOAD_IMAGE_COLOR);

  if(!img.data){
    std::cout << "imagem nao carregou corretamente\n";
    return(-1);
  }
  imshow("Original", img);

  ch[0] = Mat(img.size(), CV_8UC3);
  ch[1] = Mat(img.size(), CV_8UC3);
  ch[2] = Mat(img.size(), CV_8UC3);

  for(int y = 0; y < img.rows; y++)
  for(int x = 0; x < img.cols; x++)
  {
    ch[0].at<Vec3b>(y,x)[0] = img.at<Vec3b>(y,x)[0];//B
    ch[1].at<Vec3b>(y,x)[1] = img.at<Vec3b>(y,x)[1];//G
    ch[2].at<Vec3b>(y,x)[2] = img.at<Vec3b>(y,x)[2];//R
  }

  imshow("Canal B", ch[0]);
  imshow("Canal G", ch[1]);
  imshow("Canal R", ch[2]);

  imwrite("canal_B.png", ch[0]);
  imwrite("canal_G.png", ch[1]);
  imwrite("canal_R.png", ch[2]);

  imwrite("entrada_q3a.png", img);

  waitKey(0);
  return 0;
}

//Este programa recebe uma imagem como entrada e inverte a mesma, espelha na vertical,
//exibi e salva o resultado
#include <opencv2/opencv.hpp>
using namespace cv;

int main(int argc, char**argv)
{
  Mat img;
  Mat imgFlip;

  img = imread(argv[1],CV_LOAD_IMAGE_COLOR);

  if(!img.data){
    std::cout << "imagem nao carregou corretamente\n";
    return(-1);
  }
  imshow("Original", img);

  imgFlip = img.clone();

  for(int y = 0; y < img.rows; y++)
  for(int x = 0; x < img.cols; x++)
  {
    imgFlip.at<Vec3b>(y,img.cols - 1 - x) = img.at<Vec3b>(y,x);
  }

  imshow("Imagem Invertida Horizontalmente", imgFlip);
  imwrite("entrada_q3b.png", img);
  imwrite("flipHorizontal.png", imgFlip);

  waitKey(0);
  return 0;
}

#include <opencv2/opencv.hpp>
using namespace cv;

const char* mainWindow = "Blending";

Mat imgA, imgB;
Mat imgC;

void blending(int, void*);

int main(int argc, char**argv)
{

  if(argc != 3)
  {
    std::cout << "Voce deve informar o caminho de duas imagens de mesmo tamanho\n";
    return(-1);
  }

  imgA = imread(argv[1],CV_LOAD_IMAGE_COLOR);
  imgB = imread(argv[2],CV_LOAD_IMAGE_COLOR);

  //Teste se as imagens foram carregadas corretamente
  if(!imgA.data){
    std::cout << "imagem "<< argv[1] <<"nao carregou corretamente\n";
    return(-1);
  }
  if(!imgB.data){
    std::cout << "imagem "<< argv[2] <<"nao carregou corretamente\n";
    return(-1);
  }
  //Testa se as imagens possuem o mesmo tamanho
  if(imgA.size() != imgB.size())
  {
    std::cout << "As imagens devem possuir o mesmo tamanho\n";
    return(-1);
  }

  imgC = imgB.clone();

  //Cria o slider, para ajustar a variavel alpha do calculo do blending
  namedWindow(mainWindow, WINDOW_AUTOSIZE);
  createTrackbar( "Alpha [0-100%]",  mainWindow,
                                     NULL,
                                     100,
                                     blending);
  int key;
  while(true)
  {
    imshow(mainWindow, imgC);
    key = waitKey(10);
    if(key == 27)//esq
      break;
  }
  return 0;
}

void blending(int pos, void*)
{
  float alpha = pos/100.0;
  for(int y = 0; y < imgA.rows; y++)
  for(int x = 0; x < imgA.cols; x++)
  {
      imgC.at<Vec3b>(y,x) = imgA.at<Vec3b>(y,x)*alpha + imgB.at<Vec3b>(y,x)*(1.0 - alpha);
  }
}

#include <opencv2/opencv.hpp>
using namespace cv;

int main(int argc, char**argv)
{
  Mat img;
  Mat result;
  Mat gradient;

  img = imread(argv[1],CV_LOAD_IMAGE_GRAYSCALE);

  if(!img.data){
    std::cout << "imagem nao carregou corretamente\n";
    return(-1);
  }
  imshow("Original", img);

  result   = Mat(img.size(), CV_32FC1);
  gradient = img.clone();

  for(int y = 0; y < img.rows; y++)
  for(int x = 0; x < img.cols; x++)
  {
    result.at<float>(y,x) = (img.at<uint8_t>(y,x)/255.0)*y*(1.0/img.rows);
    gradient.at<uint8_t>(y,x) = y*(255.0/img.rows);
  }
  //converte para um formato que eh possivel salvar, neste caso equivalente ao grayscale
  //https://docs.opencv.org/2.4/modules/core/doc/basic_structures.html#void%20Mat::convertTo(OutputArray%20m,%20int%20rtype,%20double%20alpha,%20double%20beta)%20const
  result.convertTo(result, CV_8UC1, 255);

  imshow("Resultado", result);
  imshow("Gradiente", gradient);

  imwrite("gradiente.png", gradient);
  imwrite("imagem_com_gradiente.png", result);
  imwrite("entrada_q3d.png", img);

  waitKey(0);
  return 0;
}

//Programa que tira a media aritmetica de N imagens
//Este programa carrega todas as imagens de um arquivo, cujo caminho (path)
//esta indicado pela variavel path, e calcula a media de todas essas imagens
#include <opencv2/opencv.hpp>
using namespace cv;

int main(int argc, char**argv)
{
  String path("./imagensComRuido/*.jpg");
  std::vector<String> fn;
  std::vector<Mat> imagens;
  Mat media;

  glob(path, fn, true);
  //carrega as N imagens
  for(size_t i = 0; i < fn.size(); i++)
  {
    Mat im = imread(fn[i], CV_LOAD_IMAGE_GRAYSCALE);
    if(!im.data)continue;//caso falhe na leitura, vai para o proximo arquivo
    imagens.push_back(im);
  }

  if(imagens.empty())
  {
    std::cerr << "Erro ao carrega as imagens de " << path << "\n";
    return -1;
  }

  media = Mat::zeros(imagens[0].size(), CV_32FC1);
  //calcula da media das N imagens
  for(size_t i = 0; i < imagens.size(); i++)
  {
    for(int y = 0; y < imagens[0].rows; y++)
    for(int x = 0; x < imagens[0].cols; x++)
    {
      media.at<float>(y,x) += imagens[i].at<uint8_t>(y,x)/(float)imagens.size();
    }
  }
  media.convertTo(media, CV_8UC1, 1.0, 0);

  imshow("Media", media);
  imwrite("Media.png",media);

  waitKey(0);
  return 0;
}